﻿//#define _CRT_SECURE_NO_WARNINGS 1
//#include<iostream>
//#include<iomanip>
//#include<cstring>
//
//#define MAXSIZEList 100//顺序表的大小
//
//using namespace std;
//
////顺序表的结构体
//typedef struct
//{
//	char no[8];//学号
//	char name[21];//姓名
//	float score;//分数
//}student;
//
//typedef struct
//{
//	student* data;
//	int length;
//}SqList;
//
////链表的结构体
//typedef struct LNode
//{
//	student data;
//	struct LNode* next;
//}LNode, * LinkList;
////顺序表
//void InitS(SqList& S)
//{
//	S.data = new student[MAXSIZEList];//申请MAXSIZEList大小的内存
//	S.length = 0;
//}
////链表
//void InitL(LinkList& L)
//{
//	L->next = NULL;
//}
//void InterFace()
//{
//	cout << "\n        **************    *************   ***************\n";
//	cout << "      *  1.使用顺序表      2.使用链表       0.退出系统   *" << endl;
//	cout << "        **************    *************   ***************\n";
//	cout << "\nmake a choice : ";
//}
//void InterFaceS()
//{
//	cout << "\n       ********SqList(顺序表)*************" << endl;
//	cout << "      * 1.录入            2.查看表中信息  *    " << endl;
//	cout << "      * 3.按姓名查询      4.删除学生      *   " << endl;
//	cout << "      * 5.选择位置插入    6.统计总人数    *  " << endl;
//	cout << "      *         0.退出顺序表              *" << endl;
//	cout << "       **********************************" << endl;
//	cout << "\nmake a choice : ";
//}
//void InterFaceL()
//{
//	cout << "\n        *******NodeList(链表)*********" << endl;
//	cout << "       * 1.录入          2.看表        *      " << endl;
//	cout << "       * 3.按姓名查询    4.删除信息    *     " << endl;
//	cout << "       * 5.选择插入      6.统计总人数  *    " << endl;
//	cout << "       *         0.退出链表            *   " << endl;
//	cout << "        ****************************** " << endl;
//	cout << "\nmake a choice : ";
//}
////**顺序表**
////排重学号判断函数*
//bool CkS(SqList& S, student st, int t)
//{
//	int n = 0;
//	while (n < S.length)
//	{
//		if (!(strcmp(S.data[n].no, st.no)) && n != t) { cout << "\nthe number " << st.no << " is occupied ! \n"; return true; }
//		n++;
//	}
//	return false;
//}
//
////录入学生信息*
//void IPuS(SqList& S)
//{
//	cout << "\nthe amount of the student: ";
//	int n;
//	cin >> n;
//	if ((n + S.length) < 0 || (n + S.length) > MAXSIZEList) { cout << "error: amount is illegal !!!"; return; }
//
//	cout << "\nimport " << n << " student : number(7)  name(20)  score( 0 - 150 分 ) :\n";
//
//	while (n)
//	{
//		cin >> S.data[S.length].no >> S.data[S.length].name >> S.data[S.length].score;
//		if (CkS(S, S.data[S.length], -1)) {
//			cout << "\ncontinue to import " << n << " student : number(7)  name(20)  score :\n";
//			continue;
//		}
//		while (S.data[S.length].score > 150 || S.data[S.length].score < 0)
//		{
//			cout << "\nerror: the score is overflow(0-150) \nimport the score again:";
//			cin >> S.data[S.length].score;
//		}
//		S.length++;
//		n--;
//	}
//	cout << "all the data have saved ! ";
//}
//
////查看表中所有学生信息*
//void OPuS(SqList& S)
//{
//	if (S.length == 0) { cout << "\n  it is an empty List !\n"; return; }
//	cout << "\nthe list of student :\n" << endl << "number\t\t" << "name\t\t" << "score\n";
//	int n = 0;
//	while (n < S.length) {
//		cout << S.data[n].no << "\t\t" << S.data[n].name << "\t\t" << S.data[n].score << endl;
//		n++;
//	}
//	cout << endl;
//}
//
////按姓名查找学生*
//void NaSeaS(SqList& S)
//{
//	if (S.length == 0) { cout << "\nsorry ! no data !\n"; return; }
//	cout << "\nthe name of the student : ";
//
//	char ch[21];
//	int n = 0;
//	bool flag = false;
//	bool flag1 = false;
//	cin >> ch;
//	while (n < S.length)
//	{
//		if (!(flag || flag1)) { cout << "\nthe related students : \n" << endl << "number\t\t" << "name\t\t" << "score\n"; }
//		if (!strcmp(ch, S.data[n].name)) {
//			cout << endl << S.data[n].no << "\t\t" << S.data[n].name << "\t\t" << S.data[n].score;
//			flag = true;
//		}
//		n++;
//	}
//	if (!flag) { cout << "\nsorry ! there is no this student !\n"; }
//}
//void DelS(SqList& S)
//{
//	if (S.length == 0) { cout << "\nsorry ! no data !\n"; return; }
//	cout << "\nthe position of the student : (between 1 and " << S.length << " )";
//	int n;
//	cin >> n;
//	if (n > S.length || n < 1) { cout << "\nerror: it is illegal !\n"; return; }
//	while (n < S.length)
//	{
//		S.data[n - 1] = S.data[n];
//		n++;
//	}
//	S.length--;
//	cout << "\nDeleted successfully ! \n";
//}
//
//*//在表中某个位置插入学生信息*
//void InSerS(SqList& S)
//{
//	if (S.length == MAXSIZEList) { cout << "\nwarning: The list is full !\n"; return; }
//	cout << "\nchoose the position between 1 and " << S.length + 1 << ": " << endl;
//	int n;
//	cin >> n;
//	if (n<1 || n>S.length + 1) { cout << "error: it is illegal !\n"; return; }
//	for (int t = S.length + 1 - n; t > 0; t--)
//	{
//		S.data[t + n] = S.data[t + n - 1];
//	}
//	cout << "\nimport the ( number(7) name(20) score(0-150) ):";
//	do {
//		cin >> S.data[n - 1].no >> S.data[n - 1].name >> S.data[n - 1].score;
//
//	} while (CkS(S, S.data[n - 1], n - 1));
//	while (S.data[n - 1].score > 150 || S.data[n - 1].score < 0)
//	{
//		cout << "\nthe score is overflow(0-150)\nimport the score again:";
//		cin >> S.data[n - 1].score;
//	}
//	S.length++;
//	cout << " \nthis student have saved !!! \n";
//}
//
//*//统计总人数*
//void SumS(SqList& S)
//{
//	cout << "\nthe amount of the student in the list : " << S.length << endl;
//}
//*//链表*
////排重学号函数
//bool CkL(LinkList& L, student st)
//{
//	LinkList p = L->next;
//	while (p)
//	{
//		if (!strcmp(p->data.no, st.no))
//		{
//			cout << "\nthe number " << st.no << " is occupied !\n"; return true;
//		}
//		p = p->next;
//	}
//	return false;
//}
//
////录入学生信息
//void IPuL(LinkList& L)
//{
//	cout << "\nthe amount of data : ";
//	int n;
//	cin >> n;
//	L->data.score += n;
//	if (n < 0) { cout << "error: import the number is illegal !"; return; }
//	LNode* p = L;
//	cout << "import " << n << " data:  number(7)  name(20)  score( 0 - 150 分 )\n";
//	while (n)
//	{
//		LNode* q = new LNode;
//		InitL(q);
//		cin >> q->data.no >> q->data.name >> q->data.score;
//		if (CkL(L, q->data)) { cout << "continue to import " << n << " data:  number(7)  name(20)  score( 0 - 150 分 )\n"; }
//		while (q->data.score > 150 || q->data.score < 0)
//		{
//			cout << "\nthe score is overflow(0-150)\nimport the score agian:";
//			cin >> q->data.score;
//		}
//		p->next = q;
//		p = q;
//		n--;
//	}
//	cout << "all the data have saved ! \n";
//}
//
////查看整个表的学生信息
//void OPuL(LinkList& L)
//{
//	if (L->data.score == 0) { cout << "\nit is an empty List ! "; return; }
//	cout << "\nthe list of student :\n" << endl << "number\t\t" << "name\t\t" << "score\n";
//	LinkList p = L->next;
//	while (p != NULL)
//	{
//
//		cout << p->data.no << "\t\t" << p->data.name << "\t\t" << p->data.score << endl;
//		p = p->next;
//	}
//}
//
////按姓名查找学生信息
//void NaSeaL(LinkList& L)
//{
//	if (L->data.score == 0) { cout << " \nit is an empty List !\n "; return; }
//	char ch[21];
//	bool flag = true;
//
//	cout << "\nthe name of the student : ";
//	cin >> ch;
//	LinkList p = L->next;
//	cout << "this is the list :" << endl << "number\t\t" << "name\t\t" << "score\n";
//	while (p != NULL)
//	{
//		if (!strcmp(ch, p->data.name))
//		{
//			cout << p->data.no << "\t\t" << p->data.name << "\t\t" << p->data.score << endl;
//			flag = false;
//		}
//
//		p = p->next;
//	}
//	if (flag) { cout << "sorry! no such student ! \n"; }
//}
//
////删除学生信息
//void DelL(LinkList& L)
//{
//	if (L->data.score == 0) { cout << "\n it is an empty List ! \n"; return; }
//	cout << "\nthe position of the student :";
//	int n;
//	cin >> n;
//	LinkList p = L->next;
//	while (n - 2)
//	{
//		if (!p) { cout << "\nerror: the list is not so long !\n"; return; }
//		p = p->next;
//		n--;
//	}
//	if (!(n - 2)) { p->next = p->next->next; p = p->next; delete p; --L->data.score; cout << "\nDelete successfully !\n"; }
//}
//
////选择某个位置插入学生信息
//void InSerL(LinkList& L)
//{
//	cout << "\nchooose the position between 1 and " << L->data.score + 1 << endl;
//	int n;
//	cin >> n;
//	if (n<1 || n>L->data.score + 1) { cout << "\nerror: this operation is overflow !\n"; return; }
//	LinkList p = L;
//
//	while (n - 1)
//	{
//		p = p->next;
//		n--;
//	}
//	LNode* q = new LNode;
//	cout << "\nimport the student( number(7) name(20) score( 0 - 150 分 ) ): ";
//	cin >> q->data.no >> q->data.name >> q->data.score;
//	while (CkL(L, q->data))
//	{
//		cout << "\nplease import again ( number(7) name(20) score( 0 - 150 分 ) ): ";
//		cin >> q->data.no >> q->data.name >> q->data.score;
//	}
//	while (q->data.score > 150 || q->data.score < 0)
//	{
//		cout << "\nthe score is overflow( 0 - 150 分 )\nimport the score again: ";
//		cin >> q->data.score;
//	}
//	q->next = p->next;
//	p->next = q;
//	L->data.score++;
//	cout << " \nthis student have saved !!! \n";
//}
//
////统计学生人数
//void SumL(LinkList& L)
//{
//	cout << "\nthe amount of the student in the list : " << L->data.score << endl;
//}
//int main()
//{
//	char choice;
//	SqList S;
//	InitS(S);
//	LNode* L = new LNode;
//	InitL(L);
//	L->data.score = 0;
//	do
//	{
//		InterFace();
//		cin >> choice;
//		switch (choice)
//		{
//		case '0':break;
//		case '1':char a;
//			do
//			{
//				InterFaceS();
//				cin >> a;
//				switch (a)
//				{
//				case '0':break;
//				case '1':IPuS(S); break;
//				case '2':OPuS(S); break;
//				case '3':NaSeaS(S); break;
//				case '4':DelS(S); break;
//				case '5':InSerS(S); break;
//				case '6':SumS(S); break;
//				default:cout << "\nerror: please choose the right command !\n";
//				}
//			} while (a != '0');
//			break;
//		case '2':char b;
//			do
//			{
//				InterFaceL();
//				cin >> b;
//				switch (b)
//				{
//				case '0':break;
//				case '1':IPuL(L); break;
//				case '2':OPuL(L); break;
//				case '3':NaSeaL(L); break;
//				case '4':DelL(L); break;
//				case '5':InSerL(L); break;
//				case '6':SumL(L); break;
//				default:cout << "\nplease choose the right command !\n";
//				}
//			} while (b != '0');
//			break;
//		default:cout << "\nplease make a right choose !\n";
//		}
//	} while (choice != '0');
//
//	return 0;
//}


//#include<stdio.h>
//#include<string.h>
//#include<stdlib.h>
//#include"stack.h"
//
//#define N 1000+10
//
//
//char str[N];
//
//
//unsigned char prior[7][7] = 
//{
//{'>','>','<','<','<','>','>'},
//{'>','>','<','<','<','>','>'},
//{'>','>','>','>','<','>','>'},
//{'>','>','>','>','<','>','>'},
//{'<','<','<','<','<','=',' '},
//{'<','<','<','<','<',' ','>'},
//{'<','<','<','<','<',' ','='} 
//};
//
//char OPSET[7] = { '+','-','*','/','(',')','#' };
//
//
//
//Status In(char c, char str[])//判断是否为运算符 
//{
//	int i = 0;
//	while (c != str[i])
//	{
//		i++;
//	}
//	if (i < 7)
//		return OK;
//	return ERROR;
//}
//
//void  Strcat(char* str1, char* str2)//字符串连接函数，把字符串str2连接到str1后 
//{
//	int i = 0, j = 0;
//	while (str1[i] != '\0')
//	{
//		i++;
//	}
//	while (str2[j] != '\0')
//	{
//		str1[i++] = str2[j++];
//	}
//	str1[i] = '\0';
//}
//
//Status Atoi(char* c)//把字符串转为数字 
//{
//	int data = 0, d = 0;
//	int i = 0;
//	while (c[i] != '\0')
//	{
//		data = data * 10 + c[i] - '0';
//		i++;
//	}
//	return data;
//}
//
//Status precede(int a, char b)//判断优先级函数 
//{
//	int i = 0, j = 0;
//	while (OPSET[i] != a)
//	{
//		i++;
//	}
//	while (OPSET[j] != b)
//	{
//		j++;
//	}
//	return prior[i][j];
//}
//
//
//
//Status Opereta(int a, int b, int c)//运算函数 
//{
//	switch (b)
//	{
//	case '+':
//		return a + c;
//	case '-':
//		return a - c;
//	case '*':
//		return a * c;
//	case '/':
//		return a / c;
//	}
//
//	return OK;
//}
//
//int EvaluateExpression(char* MyExpression)//算法3.4 
//{//算术表达式求值的算符优先算法。
////设OPTR和OPND分别为运算符栈和运算数栈
//	SqStack OPTR;//运算符栈，字符元素 
//	SqStack OPND;//运算数栈，实数元素 
//
//	char TempData[20];
//	int data, a, b;
//	char* c, Dr[2], e;
//	int theta;
//
//	InitStack(&OPTR);
//	Push(&OPTR, '#');
//	InitStack(&OPND);
//
//	c = MyExpression;
//	TempData[0] = '\0';
//	while (*c != '#' || GetTop(&OPTR) != '#')
//	{
//
//		if (!In(*c, OPSET))//不是运算符则进栈 
//		{
//			Dr[0] = *c;
//			Dr[1] = '\0';
//			Strcat(TempData, Dr);
//			c++;
//			if (In(*c, OPSET))//是运算符时 
//			{
//				data = Atoi(TempData);
//				Push(&OPND, data);
//				TempData[0] = '\0';
//			}
//		}
//		else
//		{
//			switch (precede(GetTop(&OPTR), *c))
//			{
//			case '<':
//				Push(&OPTR, *c);
//				c++;
//				break;
//			case '=':
//				Pop(&OPTR);
//
//				c++;
//				break;
//			case '>':
//				a = Pop(&OPND);
//				b = Pop(&OPND);
//				theta = Pop(&OPTR);
//				Push(&OPND, Opereta(b, theta, a));
//				break;
//			}
//		}
//	}
//
//	return GetTop(&OPND);
//}
//int main()
//{
//	printf("请输入表达式:");
//	while (scanf("%s", str) != EOF)
//	{
//
//		printf("%d\n\n", EvaluateExpression(str));
//		printf("请输入表达式:");
//	}
//	return 0;
//}

//# include <iostream>
//# include <algorithm>
//# include <string>
//# include <stack>
//using namespace std;
//bool CheckOperator(char c);             //判断是否为运算符
//bool CheckMatch(string str);            //判断算式是否正确
//int Prior(char c);                      //求符号的优先级
//bool CheckPrior(char c1, char c2);      //通过优先级判断是否入栈
//float CalNum(float a, float b, char c); //求单项运算的结果
//float CalResult(string str);            //计算最终结果
//int main()
//{
//	string str;
//	cout << "请输入计算式:";
//	cin >> str;
//	str.append("#");           //作为算式的终止符
//	bool t = CheckMatch(str);  //判断算式是否正确
//	if (t) {
//		float r = CalResult(str);  //计算最终结果
//		cout << "计算结果为:" << r << endl;
//	}
//	return 0;
//}
//
//bool CheckOperator(char c)   //判断是否为运算符
//{
//	if (c == '+' || c == '-' || c == '*' || c == '/') {
//		return true;
//	}
//	else {
//		return false;
//	}
//}
//
//bool CheckMatch(string str)  //判断算式是否正确
//{
//	if (CheckOperator(str[0]) || CheckOperator(str[str.length() - 2])) {
//		//算式首尾位置出现运算符
//		cout << "算术表达式错误！\n" << "原因：缺少用于运算的数" << endl;
//		return false;
//	}
//	//判断括号及运算符输入是否正确
//	stack<char>S;   //用于存放括号的栈
//	for (int i = 0; i < str.length() - 1; i++) {
//		if (!CheckOperator(str[i]) && (str[i] < 48 || str[i]>57) && str[i] != '(' && str[i] != ')' && str[i] != '.') {
//			//出现非法字符
//			cout << "算术表达式错误！\n" << "原因：出现非法字符" << str[i] << endl;
//			return false;
//		}
//		if (CheckOperator(str[i]) && CheckOperator(str[i + 1])) {
//			//运算符重复
//			cout << "算术表达式错误！\n" << "原因：运算符" << str[i] << "重复" << endl;
//			return false;
//		}
//		if (str[i] == '(')
//		{
//			S.push(str[i]);
//			if (CheckOperator(str[i + 1])) {
//				//'('后缺少用于运算的数
//				cout << "算术表达式错误！\n" << "原因：缺少用于运算的数" << endl;
//				return false;
//			}
//		}
//		if (str[i] == ')')
//		{
//			if (S.empty()) {
//				//若栈已为空，说明遗漏左括号
//				cout << "算术表达式错误！\n" << "原因：遗漏左括号" << endl;
//				return false;
//			}
//			S.pop();
//		}
//	}
//	if (!S.empty()) {
//		//若此时栈还不为空，说明遗漏右括号
//		cout << "算术表达式错误！\n" << "原因：遗漏右括号" << endl;
//		return false;
//	}
//	return true;
//}
//
//int Prior(char c)    //返回符号的优先级
//{
//	switch (c)
//	{
//	case '#': return 0;
//	case '+':
//	case '-': return 1;
//	case '*':
//	case '/': return 2;
//	case ')': return 3;
//	case '(': return 4;
//	}
//}
//
//bool CheckPrior(char c1, char c2) //通过优先级判断是否入栈（c1当前，c2栈中）
//{
//	if (c2 == '(') {
//		return true;  //同意进栈
//	}
//	int p1 = Prior(c1);
//	int p2 = Prior(c2);
//	if (p1 > p2) {   //当前运算符的优先级较高
//		return true; //同意进栈
//	}
//	else {
//		return false; //不同意进栈
//	}
//}
//
//float CalNum(float a, float b, char c) //求单项运算的结果
//{
//	switch (c)
//	{
//	case '+': return a + b;
//	case '-': return a - b;
//	case '*': return a * b;
//	case '/': return a / b;
//	}
//}
//
//float CalResult(string str) //计算最终结果
//{
//	stack<float>Num;  //保存运算数的栈
//	stack<char>Sign;  //保存运算符的栈
//	Sign.push('#');
//	float a, b;
//	for (int i = 0; i < str.length() && !Sign.empty(); i++) {
//		if (str[i] >= 48 && str[i] <= 57) {
//			//若为数字
//			a = float(str[i]) - 48;           //a保存由字符转化为数字后的值
//			int j;
//			//将字符转化为数字
//			for (j = i + 1; (str[j] == '.') || (j < str.length() && str[j] >= 48 && str[j] <= 57); j++) {
//				if (str[j] == '.') {
//					//若为小数
//					int k, l;
//					for (k = j + 1, l = 1; k < str.length() && str[k] >= 48 && str[k] <= 57; k++, l++) {
//						b = float(str[k]) - 48;
//						a = a + b * pow(10, -l);
//					}
//					j = k;
//					break;
//				}
//				else {
//					b = float(str[j]) - 48;
//					a = a * 10 + b;
//				}
//			}
//			i = j - 1;
//			Num.push(a);  //运算数进栈
//		}
//		else {
//			//若为运算符
//			char c1 = str[i];  //c1当前运算符
//			while (1) {
//				char c2 = Sign.top();             //c2栈顶运算符
//				if (c2 == '#' && str[i] == '#') { //若遇到起始符，并且str也到达末尾
//					Sign.pop();
//					break;
//				}
//				bool t = CheckPrior(c1, c2);     //通过优先级判断是否入栈（c1当前，c2栈中）
//				if (t) {
//					//同意运算符进栈
//					int s = Prior(str[i]);
//					if (s == 3) {
//						//出现')'，优先进行括号内的运算
//						while ((c2 = Sign.top()) != '(') {
//							a = Num.top();  //取出第一个数
//							Num.pop();
//							b = Num.top();  //取出第二个数
//							Num.pop();
//							float r = CalNum(b, a, c2);  //求单项运算的结果
//							Sign.pop();
//							Num.push(r);    //运算得到的新数进栈
//						}
//						Sign.pop();
//					}
//					else {
//						Sign.push(c1); //运算符进栈
//					}
//					break;
//				}
//				else {
//					//不同意运算符进栈，执行运算操作
//					a = Num.top();
//					Num.pop();
//					b = Num.top();
//					Num.pop();
//					float r = CalNum(b, a, c2); //求单项运算的结果
//					Sign.pop();
//					Num.push(r);
//				}
//			}
//		}
//	}
//	return Num.top();
//}
//#include<stdio.h>
//#include<iostream>
//using namespace std;
//
//struct Node 
//{
//	char data;
//	Node* next;
//};
//
//Node* creat() {
//	int lengh = 0;
//	Node* q;
//	Node* node;
//	Node* head = new Node;
//	head->next = nullptr;
//	q = head;
//	char ch;
//
//	while (cin >> ch) {
//
//		node = new Node;
//		if (node != nullptr) {
//			node->data = ch;
//			q->next = node;
//			q = q->next;
//			lengh++;
//		}
//		if (getchar() == '\n')break;
//
//	}
//	q->next = nullptr;
//
//	cout << "字符串的长度为：" << lengh << endl;
//
//	return head;
//}
//
//
//Node* Copy_Node(Node* head) {
//	Node* head2 = new Node;
//	Node* p = head;
//	Node* q = head2;
//	Node* node;
//	while (p->next != nullptr) {
//		node = new Node;
//		if (node != nullptr) {
//			node->data = p->next->data;
//			q->next = node;
//			q = q->next;
//			p = p->next;
//		}
//	}
//	q->next = nullptr;
//	return head2;
//}
//
//Node* delet(Node* head) {
//	cout << "要删除的字符或子字符串： ";
//	int times = 0;
//	Node* q00 = head;
//	Node* p00 = creat();
//	Node* q10 = q00->next;
//	Node* p10 = p00->next;
//	Node* p0 = p00;
//	Node* q0 = q00;
//	Node* q1 = q00->next;
//	Node* p1 = p00->next;
//	Node* De1, * De2;
//	while (q1 != nullptr) {
//		p0 = p00;
//		while (q1 != nullptr && p0->next != nullptr) {
//			if (q1->data == p0->next->data) {
//				q1 = q1->next;
//				p0 = p0->next;
//			}
//			else {
//				q0 = q10;
//				q1 = q10->next;
//				q10 = q10->next;
//				p0 = p00;
//			}
//		}
//		if (p0->next == nullptr) {
//			De1 = q0->next;
//			q0->next = q1;
//			q10 = q1;
//			times++;
//			//释放需要删除的链表内存空间
//			while (De1 != q1) {
//				De2 = De1;
//				De1 = De1->next;
//				delete(De2);
//
//			}
//		}
//		else {
//			if (time == 0)
//				cout << "没有找到待删除的字符或字符串!" << endl;
//		}
//	}
//	return head;
//}
//
//Node* change(Node* head) {
//	cout << "要替换的字符或子字符串： " << endl;
//	Node* q00 = head;
//	Node* p00 = creat();
//	cout << "替换的新字符串：" << endl;
//	Node* c = creat();
//	Node* q10 = q00->next;
//	Node* p10 = p00->next;
//	Node* p0 = p00;
//	int times = 0;
//	Node* q0 = q00;
//	Node* q1 = q00->next;
//	Node* p1 = p00->next;
//	Node* Dr1, * Dr2;
//	while (q1 != nullptr) {
//		p0 = p00;
//		while (q1 != nullptr && p0->next != nullptr) {
//			if (q1->data == p0->next->data) {
//				q1 = q1->next;
//				p0 = p0->next;
//			}
//			else {
//				q0 = q10;
//				q1 = q10->next;
//				q10 = q10->next;
//				p0 = p00;
//			}
//		}
//		if (p0->next == nullptr) {
//			Dr1 = q0->next;
//			Node* d = Copy_Node(c);
//			Node* d1 = d->next;
//			q0->next = d1;
//			while (d1->next != nullptr) {
//				d1 = d1->next;
//			}
//			q0 = d1;
//			//*******************无法避免对空指针的引用？
//			d1->next = q1;
//			q10 = q1;
//			times++;
//			//释放需要替换的字符或字符串的内存空间
//			while (Dr1 != q1) {
//				Dr2 = Dr1;
//				Dr1 = Dr1->next;
//				delete(Dr2);
//			}
//
//		}
//		else {
//			if (time == 0)
//				cout << "没有找到待替换的字符或字符串!" << endl;
//		}
//	}
//	return head;
//}
//
//
//Node* Copy_Node(Node* head) {
//	Node* head2 = new Node;
//	Node* p = head;
//	Node* q = head2;
//	Node* node;
//	while (p->next != nullptr) {
//		node = new Node;
//		if (node != nullptr) {
//			node->data = p->next->data;
//			q->next = node;
//			q = q->next;
//			p = p->next;
//		}
//	}
//	q->next = nullptr;
//	return head2;
//}
//
//void print(Node* head) {
//	Node* p = head->next;
//	while (p != nullptr) {
//		cout << p->data;
//		p = p->next;
//	}
//	cout << endl;
//}
//
//void serch(Node* head) 
//{
//	cout << "要查找的字符或子字符串： ";
//	Node* q = head;
//	Node* p0 = creat();
//	Node* p;
//	Node* p1 = q->next;
//	int num = 0;
//	int times = 0;
//	while (q->next != nullptr) {
//		p = p0;
//		while (q->next != nullptr && p->next != nullptr) {
//
//			if (p->next->data == q->next->data) {
//				p = p->next;
//				q = q->next;
//
//			}
//			else {
//				q = p1;
//				p = p0;
//				p1 = p1->next;
//				num++;
//			}
//		}
//		if (p->next == nullptr) {
//			cout << "查找的字符或字符串的数学位置为：" << ++num << endl;
//			q = p1;
//			p1 = p1->next;
//
//			times++;
//		}
//		else {
//			if (time == 0)
//				cout << "没有找到该字符或字符串!" << endl;
//		}
//	}
//	cout << "字符或字符串出现的次数：" << times << endl;
//}
//​
//​
//int main()
//{
//	Node* p = creat(), * head, * q1, * q2;
//
//	print(p);
//	serch(p);
//	//number(p);
//	print(delet(p));
//	//在删除操作基础上继续执行替换操作
//	head = change(p);
//	print(head);
//	q1 = head->next;
//	while (q1 != nullptr) {
//		q2 = q1;
//		q1 = q1->next;
//		delete(q2);
//
//	}
//	//链表内存已全部释放，再次访问将出现访问错误
//	//print(head);
//	return 0;
//}
//
//#include<stdio.h>
//
//​
//BiTree CreatePreTree()//建立二叉树 
//{
//	char c;
//	scanf("%c", &c);
//	if (c == '#')  //表示空子树
//		return NULL;
//	else
//	{
//		BiTree T = (BiTree)malloc(sizeof(BiTreeNode));
//		T->data = c;
//		T->leftChild = CreatePreTree();
//		T->rightChild = CreatePreTree();
//		return T;
//	}
//}
//
//
//void PreOrder(BiTreeNode* root, void visit(DataType item)) 
//{
//	//前序遍历二叉树root，访问操作为visit
//	if (root != NULL)
//	{
//		visit(root->data);
//		PreOrder(root->leftChild, visit);
//		PreOrder(root->rightChild, visit);
//	}
//}
//void InOrder(BiTreeNode* root, void visit(DataType item)) {
//	//中序遍历二叉树root，访问操作为visit
//	if (root != NULL)
//	{
//		InOrder(root->leftChild, visit);
//		visit(root->data);
//		InOrder(root->rightChild, visit);
//	}
//}
//
//void PostOrder(BiTreeNode* root, void visit(DataType item)) {
//	//后序遍历二叉树root，访问操作为visit
//	if (root != NULL)
//	{
//		PostOrder(root->leftChild, visit);
//		PostOrder(root->rightChild, visit);
//		visit(root->data);
//	}
//}​
//
//int Treehigh(BiTree bt)
//{
//	int lefthigh, righthigh, high;
//	if (bt == NULL)  high = 0;//空树
//	else
//	{
//		lefthigh = Treehigh(bt->leftChild);
//		righthigh = Treehigh(bt->rightChild);
//		int i = lefthigh > righthigh ? lefthigh : righthigh;//找到子树的深度
//		high = i + 1;//子树深度+1=树的深度
//	}
//	return high;
//}
//
//
//int Count1(BiTree bt)//计算叶子结点个数
//{
//	if (bt == NULL) return 0;
//	else if (bt->leftChild == NULL && bt->rightChild == NULL)
//		return 1;
//	else
//		return (Count1(bt->leftChild) + Count1(bt->rightChild));
//}
//int Count2(BiTree bt)//计算度为2的节点的数量
//{
//	int num = 0;
//	if (bt)
//	{
//		if (bt->leftChild != NULL && bt->rightChild != NULL)
//		{
//			num = 1;
//		}
//		num += Count2(bt->leftChild) + Count2(bt->rightChild);
//	}
//	return num;
//}
//
//
//int main()
//{
//	BiTree T;
//	char sel = ' ';
//	while (sel != '0')
//	{
//		printf("------二叉树演示系统-------\n");
//		printf("   版本:1.0   作者:XXX 日期:2022-05-07\n");
//		printf("------------------------------------------\n");
//		printf("       1.创建二叉树\n");
//		printf("       2.先序排列操作\n");
//		printf("       3.中序排列操作\n");
//		printf("       4.后序排列操作\n");
//		printf("       5.输出二叉树的叶子节点和度为2的节点的数量\n");
//		printf("       6.输出二叉树的深度\n");
//		printf("       7.将二叉树所有节点的左右子树互换\n");
//		printf("       8.层序排列操作\n");
//		printf("       9.删除二叉树\n");
//		printf("       0.退出系统\n");
//		printf("请输入选项[0-9]:");
//		sel = _getch();
//		switch (sel)
//		{
//		case '1':
//			printf("创建二叉树.\n");
//			T = CreatePreTree();
//			system("pause");
//			break;
//		case '2':
//			printf("先序排列操作.\n");
//			printf("前序遍历:");
//			PreOrder(T, visit);//前序遍历
//			system("pause");
//			break;
//		case '3':
//			printf("中序排列操作.\n");
//			printf("\n中序遍历:");
//			InOrder(T, visit);//中序遍历
//			system("pause");
//			break;
//		case '4':
//			printf("后序排列操作.\n");
//			printf("\n后序遍历:");
//			PostOrder(T, visit);//后序遍历
//			system("pause");
//			break;
//		case '5':
//			printf("输出二叉树的叶子节点和度为2的节点的数量.\n");
//			printf("叶子节点：%d个  \n", Count1(T));
//			printf("度为2的节点:%d个\n", Count2(T));
//			system("pause");
//			break;
//		case '6':
//			printf("输出二叉树的深度.\n");
//			printf("二叉树的深度为：%d\n", Treehigh(T));
//			system("pause");
//			break;
//		case '7':
//			printf("将二叉树所有节点的左右子树互换.\n");
//			ChangeTree(T);
//			system("pause");
//			break;
//		case '8':
//			printf("层序排列操作.\n");
//			printf("\n层序遍历:\n");
//			LevelOrder(T);//层序遍历
//			system("pause");
//			break;
//		case '9':
//			printf("删除二叉树.\n");
//			Destory(T);
//			printf("删除成功\n");
//			system("pause");
//			break;
//		case '0':
//			printf("\n谢谢使用，再见！\n");
//			break;
//		default:
//			printf("您输入的选项不合法，请重新选择！\n");
//		}
//	}
//	return 0;
//}
//
//#include<iostream>
//using namespace std;
//#include<stack>
//
////二叉树结点
//typedef struct BTNode
//{
//	char root;
//	struct BTNode* lchild;
//	struct BTNode* rchild;
//}BTree;
//
////创建二叉树
//BTree* CreateBinaryTree()
//{
//	char ch;
//	cin >> ch;
//	BTree* node;
//
//	if (ch == '#') {
//		node = NULL;
//	}
//	else {
//		node = (BTree*)malloc(sizeof(BTree));
//		if (ch) {
//			node->root = ch;
//			node->lchild = CreateBinaryTree();
//			node->rchild = CreateBinaryTree();
//		}
//	}
//	return node;
//}
//
////二叉树叶子结点个数
//int CountLeaf(BTree* root, int* count)
//{
//	if (root != NULL && root->lchild == NULL && root->rchild == NULL) {
//		(*count)++;
//	}
//
//	if (root != NULL) {
//		CountLeaf(root->lchild, count);
//		CountLeaf(root->rchild, count);
//	}
//	return *count;
//}
//
//int Num(BTree T)
//{
//	if (T == NULL)
//	{
//		return 0;
//	}
//	if (T->lchild != NULL && T->rchild != NULL)      /*某结点有左右子树*/
//	{
//		return Num(T->lchild) + Num(T->rchild);
//	}
//	else if (T->lchild != NULL && T->rchild == NULL)  /*某结点只有左子树*/
//	{
//		return 1 + Num(T->lchild);
//	}
//	else if (T->lchild == NULL && T->rchild != NULL)   /*某结点只有右子树*/
//	{
//		return 1 + Num(T->rchild);
//	}
//	return 0;
//}
//
////输出栈中元素
//void printStack(stack<char>path) 
//{
//	while (!path.empty()) {
//		char c = path.top();
//		cout << c << "-";
//		path.pop();
//	}
//	cout << endl;
//}
////递归主体
//void printLeaf(BTree* root, stack<char>path) {
//	if (root == NULL)return;
//
//	path.push(root);//非空就入栈
//
//	if (root->lchild == NULL && root->rchild == NULL)printStack(path);//若为叶子结点就输出栈
//
//	printLeaf(root->lchild, path);
//	printLeaf(root->rchild, path);
//}
//
//void swap(struct BinaryTree* tree)    //交换左右子树
//{
//	struct BinaryTree* temp;
//
//	if (tree == NULL)
//		return;
//
//	temp = tree->lchild;
//	tree->lchild = tree->rchild;
//	tree->rchild = temp;
//
//	swap(tree->lchild);     //递归交换左二叉树
//	swap(tree->rchild);	    //递归交换右二叉树
//}
//
//int main()
//{
//	//创建二叉树
//	BTree* root = CreateBinaryTree();
//
//	//二叉树叶子结点个数
//	int count = 0;
//	cout << "二叉树叶子结点个数为：" << CountLeaf(root, &count) << endl;
//	return 0;
//}